[์๋ฐ ์น ํ๋ก๊ทธ๋๋ฐ Next Step - ๋ฐ์ฌ์ฑ]์ ์ฝ๊ณ ์ธ์ฉํ๊ณ ์ ๋ฆฌํ๋ POST์ ๋๋ค.
๐ฉ ํ๋์ setter ๋ฉ์๋์ @Inject ๊ธฐ๋ฅ ์ถ๊ฐ
๐ง ์๊ตฌ์ฌํญ
@Inject ๋ฅผ ํ์ฉํด DIํจ์ผ๋ก์จ ๋น ๊ฐ์ ์์กด๊ด๊ณ๋ฅผ ์ฝ๊ฒ ์ฐ๊ฒฐํ ์ ์๋ค. ํ์ง๋ง ํ์ฌ๋ ์์ฑ์๋ฅผ ํตํด์๋ง DI๊ฐ ๊ฐ๋ฅํ๋ค. ๋ฐ๋ผ์ ์์ฑ์ ์ด์ธ์ ํ๋, setter ๋ฉ์๋๋ฅผ ํตํด์๋ DIํ ์ ์๋๋ก ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ค.
๐ง 1๋จ๊ณ ํํธ - ํด๋์ค ์ค๊ณ
์์ฑ์, ํ๋, setter ๋ฉ์๋, ์ด 3๊ฐ์ง์ ๊ฒฝ์ฐ์ ์๊ฐ ์๋ค. ์ง๊ธ๊น์ง ์ฌ๋ฌ ๊ฒฝ์ฐ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ ์ถ์ํ ๊ณผ์ ์ ํตํด ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ฐํ ํ ๊ฐ ๊ฒฝ์ฐ์ ๋ํ ๊ตฌํ์ ์ํํ๋ค.
BeanFactory ์ ์ญํ ์ ๋น์ ์ถ๊ฐํ๊ณ , ์กฐํํ๋ ์ญํ ๋ง ๋จ๊ธฐ๊ณ ์์ฑ์๋ฅผ ํ์ฉํด DI๋ฅผ ํ๊ณ ์ธ์คํด์ค ์์ฑ์ ConstructorInjector ๋ผ๋ ์ด๋ฆ์ผ๋ก ๋ถ๋ฆฌํ๋ค.
Injector๋ผ๋ ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ฐํ๋ค. ์ด๋ ์์ฑ์, ํ๋,setter๋ฉ์๋ DI์ ๋ํ ์ถ์ ๋ฉ์๋๋กinject()๋ฅผ ๊ฐ์ง๋ค.-
์์ฑ์, ํ๋,
setter๋ฉ์๋์ ๋ํ DI๋ฅผ ๋ด๋นํ๋ ํด๋์ค๋ฅผ ๊ตฌํํ๋ค. ์ด๋Injector์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค.- 3๊ฐ์ ๊ตฌํ์ฒด๋ฅผ ๊ตฌํํ๋ ๊ณผ์ ์์ ๋ฐ์ํ๋ ์ค๋ณต ์ฝ๋๋ค์
Injector์ธํฐํ์ด์ค์ ๊ตฌํ์ฒด ์ฌ์ด์AbstractInjector์ ๊ฐ์ ์ถ์ ํด๋์ค๋ก ์ ๊ฑฐํ๋ค.
- 3๊ฐ์ ๊ตฌํ์ฒด๋ฅผ ๊ตฌํํ๋ ๊ณผ์ ์์ ๋ฐ์ํ๋ ์ค๋ณต ์ฝ๋๋ค์
๐ง 2๋จ๊ณ ํํธ
์์ฑ์ ๊ตฌํ์ฒด(ConstructorInjector)๋ @Inject ๊ฐ ์ค์ ๋์ด ์๋ ์์ฑ์๋ฅผ ๊ฐ์ง๋ ํด๋์ค๋ฅผ ์ฐพ๋๋ค.
- ์์ฑ์์ ์ธ์์ ํด๋นํ๋ ๋น์ด
BeanFactory์ ๋ฑ๋ก๋์ด ์๋์ง ํ์ธํด๋ณด๊ณ ๋ฑ๋ก๋์ด ์์ง ์๋ค๋ฉด ๋น ์ธ์คํด์ค๋ฅผ ์์ฑํ์ฌ DIํ๋ค.
ํ๋ ๊ตฌํ์ฒด(FieldInjector)์ setter ๋ฉ์๋ ๊ตฌํ์ฒด(SetterInjector) ๋ํ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค.
- ํ๋ ๊ตฌํ์ฒด์ ๊ฒฝ์ฐ ํด๋์ค์
@Injector๊ฐ ์ค์ ๋์ด ์๋ ๋ชจ๋ ํ๋๋ฅผ ์ฐพ๋๋ค. - ํ๋ ํ์ (ํด๋์ค)์ ํด๋นํ๋ ๋น์ด ๋ฑ๋ก๋์ด ์๋์ง ํ์ธํด๋ณด๊ณ ๋ฑ๋ก๋์ด ์์ง ์๋ค๋ฉด ๋น ์ธ์คํด์ค๋ฅผ ์์ฑํ์ฌ DIํ๋ค.
๐ง ์ค๋ณต ์ ๊ฑฐ๋ฅผ ์ํ ํํธ
@Injector ๊ฐ ์ค์ ๋์ด ์๋ ์์น๊ฐ ๋ค๋ฅด๋ค๋ ์ ์ ์ ์ธํ๋ฉด, 3๊ฐ์ ๊ตฌํ์ฒด์ ๋ก์ง ์ฒ๋ฆฌ ๊ณผ์ ์ ๋์ผํ๋ค.
- ์ด์ ๊ฐ์ด ๋ก์ง์ด ๊ฐ์ ๊ฒฝ์ฐ ํ ํ๋ฆฟ ๋ฉ์๋ ํจํด์ ์ ์ฉํ ์ ์๋ค.
- ๋ถ๋ชจ ํด๋์ค์ธ
AbstractInjector๋ ๋ก์ง ๊ตฌํ์ ๋ด๋นํ๊ณ , 3๊ฐ์ ํ์ ํด๋์ค(๊ตฌํ์ฒด)๋ ๊ฐ ํด๋์ค๋ง๋ค ๋ค๋ฅธ ๋ถ๋ถ๋ง์ ๊ตฌํํ๋ค.
๐ฉ ํ๋์ setter ๋ฉ์๋ @Inject ๊ตฌํ
ConstructorInjector ๋ ์ด์ ์ ๊ตฌํํ BeanFactory ์ instantiateClass() , instantiateConstructor() ๋ฉ์๋์ ๊ฐ๋ค.
- ๋ค๋ฅธ ์ ์ ๋น์ ์ ์ฅํ๊ธฐ ์ํ
Map์ ์ง์ ๊ฐ์ง์ง ์๊ณBeanFactory๋ฅผ ํตํด ์ ๊ทผํ๋๋ก ํ๋ค๋ ๊ฒ์ด๋ค. ConstructorInjector์instantiateClass()๋ ์์ผ๋ก ์ถ๊ฐํFieldInjector,SetterInjector๋ ํ์ํ๋ฏ๋ก, ์ด๋ค์ ์ค๋ณต ์ ๊ฑฐ๋ฅผ ์ํ ํด๋์ค์ธAbstractInjector์์ ๊ตฌํํ๋๋ก ํ๋ค.
public abstract class AbstractInjector implements Injector {
private BeanFactory beanFactory;
public AbstractInjector(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public void inject(Class<?> clazz) {
instantiateClass(clazz);
Set<?> injectedBeans = getInjectedBeans(clazz);
for (Object injectedBean : injectedBeans) {
Class<?> beanClass = getBeanClass(injectedBean);
inject(injectedBean, instantiateClass(beanClass), beanFactory);
}
}
abstract Set<?> getInjectedBeans(Class<?> clazz);
abstract Class<?> getBeanClass(Object injectedBean);
abstract void inject(Object injectedBean, Object bean, BeanFactory beanFactory);
private Object instantiateClass(Class<?> clazz) {
Class<?> concreteClass = findBeanClass(clazz, beanFactory.getPreInstanticateBeans());
Object bean = beanFactory.getBean(concreteClass);
if (bean != null) {
return bean;
}
Constructor<?> injectedConstructor = BeanFactoryUtils.getInjectedConstructor(concreteClass);
if (injectedConstructor == null) {
bean = BeanUtils.instantiate(concreteClass);
beanFactory.registerBean(concreteClass, bean);
return bean;
}
bean = instantiateConstructor(injectedConstructor);
beanFactory.registerBean(concreteClass, bean);
return bean;
}
private Object instantiateConstructor(Constructor<?> constructor) {
Class<?>[] pTypes = constructor.getParameterTypes();
List<Object> args = Lists.newArrayList();
for (Class<?> clazz : pTypes) {
Class<?> concreteClazz = BeanFactoryUtils.findConcreteClass(clazz, beanFactory.getPreInstanticateBeans());
Object bean = beanFactory.getBean(concreteClazz);
if (bean == null) {
bean = instantiateClass(concreteClazz);
}
args.add(bean);
}
return BeanUtils.instantiateClass(constructor, args.toArray());
}
private Class<?> findBeanClass(Class<?> clazz, Set<Class<?>> preInstanticateBeans) {
Class<?> concreteClazz = BeanFactoryUtils.findConcreteClass(clazz, preInstanticateBeans);
if (!preInstanticateBeans.contains(concreteClazz)) {
throw new IllegalStateException(clazz + "๋ Bean์ด ์๋๋ค.");
}
return concreteClazz;
}
}
BeanFactory์private์์๋ค์ ๋ํ ์ ๊ทผ์ ์ํดBeanFactory์ ์ ์ธํgetBean(),getPreInstanticateBeans(),registerBean()๋ฉ์๋๋ฅผ ํ์ฉํ๋ค.
public class ConstructorInjector extends AbstractInjector {
public ConstructorInjector(BeanFactory beanFactory) {
super(beanFactory);
}
@Override
Set<?> getInjectedBeans(Class<?> clazz) {
return Sets.newHashSet();
}
@Override
Class<?> getBeanClass(Object injectedBean) {
return null;
}
@Override
void inject(Object injectedBean, Object bean, BeanFactory beanFactory) {
}
}
ConstructorInjector๋ ๊ตฌํ ๋ก์ง์ด ๋ชจ๋AbstractInjector๋ก ์ด๋ํ์ผ๋ฏ๋ก ๊ฐ๋จํ๋ค.
public class FieldInjector extends AbstractInjector {
private static final Logger log = LoggerFactory.getLogger(FieldInjector.class);
public FieldInjector(BeanFactory beanFactory) {
super(beanFactory);
}
@Override
Set<?> getInjectedBeans(Class<?> clazz) {
return BeanFactoryUtils.getInjectedFields(clazz);
}
@Override
Class<?> getBeanClass(Object injectedBean) {
Field field = (Field)injectedBean;
return field.getType();
}
@Override
void inject(Object injectedBean, Object bean, BeanFactory beanFactory) {
Field field = (Field) injectedBean;
try {
field.setAccessible(true);
field.set(beanFactory.getBean(field.getDeclaringClass()), bean);
} catch (IllegalAccessException | IllegalArgumentException e) {
log.error(e.getMessage());
}
}
}
public class SetterInjector extends AbstractInjector {
private static final Logger log = LoggerFactory.getLogger(SetterInjector.class);
public SetterInjector(BeanFactory beanFactory) {
super(beanFactory);
}
@Override
Set<?> getInjectedBeans(Class<?> clazz) {
return BeanFactoryUtils.getInjectedMethods(clazz);
}
@Override
Class<?> getBeanClass(Object injectedBean) {
Method method = (Method) injectedBean;
Class<?>[] paramTypes = method.getParameterTypes();
if (paramTypes.length != 1) {
throw new IllegalStateException("DIํ ๋ฉ์๋ ์ธ์๋ ํ๋์ฌ์ผ ํฉ๋๋ค.");
}
return paramTypes[0];
}
@Override
void inject(Object injectedBean, Object bean, BeanFactory beanFactory) {
Method method = (Method) injectedBean;
try {
method.invoke(beanFactory.getBean(method.getDeclaringClass()), bean);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
log.error(e.getMessage());
}
}
}
ํ
ํ๋ฆฟ ๋ฉ์๋ ํจํด์ ์ ์ฉํด ๋ก์ง ์ค๋ณต์ ์ ๊ฑฐํ์ฌ ํ์ ํด๋์ค์ ๊ตฌํ์ด ๋งค์ฐ ๊ฐ๋จํด์ก๋ค. ์ด์ BeanFactory ๊ฐ ๋ฐฉ๊ธ๊น์ง ๊ตฌํํ 3๊ฐ์ Injector ๋ฅผ ์ฌ์ฉํ๋๋ก ๋ฆฌํฉํ ๋งํ๋ค.
public class BeanFactory {
private static final Logger logger = LoggerFactory.getLogger(BeanFactory.class);
private Set<Class<?>> preInstanticateBeans;
private Map<Class<?>, Object> beans = Maps.newHashMap();
private List<Injector> injectors;
public BeanFactory(Set<Class<?>> preInstanticateBeans) {
this.preInstanticateBeans = preInstanticateBeans;
injectors = Arrays.asList(
new FieldInjector(this),
new SetterInjector(this),
new ConstructorInjector(this)
);
}
public void initialize() {
for (Class<?> clazz : preInstanticateBeans) {
if (beans.get(clazz) == null) {
logger.debug("instantiated Class : {}", clazz);
inject(clazz);
}
}
}
private void inject(Class<?> clazz) {
for (Injector injector : injectors) {
injector.inject(clazz);
}
}
...
}
BeanFactory์์ฑ์ ํธ์ถ ์, ๊ตฌํํInjector๋ค์ ์ด๊ธฐํํด์ฃผ๊ณ ,initialize()๋ฉ์๋ ํธ์ถ๋ก, ์ด๊ธฐํํInjector๋ค์ ๋ํ DI๋ฅผ ์ํํ๋ค.
๐ฉ @Inject ๊ฐ์
BeanFactory ์ AbstractInjector ์ฝ๋๋ฅผ ๋ณด๋ฉด, ์ค๋ณต์ ์ ๊ฑฐํ๊ธฐ๋ ํ์ง๋ง ์์ค ์ฝ๋์ ์ดํด๋๊ฐ ๋จ์ด์ง๋ค. ๋ํ, ํ์ฌ ๋ชจ๋ ๋น๊ณผ ๊ด๋ จํ ์ ๋ณด๋ BeanFactory ๊ฐ ๊ด๋ฆฌํ๋๋ฐ, ๋น ์ธ์คํด์ค ์์ฑ๊ณผ ์ฃผ์
์ Injector ๊ตฌํ ํด๋์ค๊ฐ ๋ด๋นํ๋ ๊ตฌ์กฐ์ฌ์ BeanFactory ์๊ฒ ์ผ์ ์ํค๋ ๊ฒ์ด ์๋ ๋น ์ ๋ณด ์กฐํ๊ฐ ๊ณ์ ๋ฐ์ํ๋ค.
- ์ฆ,
BeanFactory๊ฐ์ฒด์ ํ์ฉ๋๊ฐ ๋จ์ด์ง๋ ๊ตฌ์กฐ์ด๋ค. - ํ์ฉ๋๋ฅผ ๋์ด๊ธฐ ์ํด ๋น ์ธ์คํด์ค ์์ฑ๊ณผ ์ฃผ์
์์
์
BeanFactory๊ฐ, ํ์ฌ ๋น ํด๋์ค์ ์ํ ์ ๋ณด๋ฅผ ๋ณ๋์ ํด๋์ค๋ก ์ถ์ํ(BeanDefinition)ํด ๊ด๋ฆฌํ๊ฒ๋ ํ๋ค. -
์ค์ ๋ annotation์ ์๋ ํด๋์ค๋ฅผ ์กฐํํ๋ ์ญํ ์ ํ๋
BeanScannerํด๋์ค์ ์ด๋ฆ๋ClasspathBeanDefinitionScanner๋ก renameํ๋ค.- ์ด๋ annotation์ด ์ค์ ๋ ํด๋์ค๋ฅผ ์กฐํํ ํ
BeanDefinition์ ์์ฑํดBeanFactory์ ์ ๋ฌํ๋ค. ์ด๋,ClasspathBeanDefinitionScanner์BeanFactory๊ฐ ๊ฐํ ์์กด๊ด๊ณ๋ฅผ ๊ฐ์ง์ง ์๋๋ก ์ค๊ณํ๋ค. (BeanDefinition์BeanFactory์ ์ ๋ฌํ๋ ๋ถ๋ถ์์๋ง ๋ฐ์ํ๋๋ก ๊ตฌํ,BeanDefinition์ ์ ์ฅํ๋ ์ธํฐํ์ด์ค(BeanDefinitionRegistry)๋ฅผ ์ถ๊ฐํ์ฌ ์์กด๊ด๊ณ๋ฅผ ๋์จํ๊ฒ!) - ์ฆ,
BeanFactory๋BeanDefinition์ ์ ์ฅํ๋ ์ ์ฅ์ ์ญํ ๊ณผBeanDefinition์ ํ์ฉํด ๋น ์ธ์คํด์ค ์์ฑ, ์์กด๊ด๊ณ ์ฃผ์ ์ ๋ด๋นํ๋ ์ญํ ๋ก ๋๋๋ค.
- ์ด๋ annotation์ด ์ค์ ๋ ํด๋์ค๋ฅผ ์กฐํํ ํ
public interface BeanDefinitionRegistry {
void registerBeanDefinition(Class<?> clazz, BeanDefinition beanDefinition);
}
public class ClasspathBeanDefinitionScanner {
private final BeanDefinitionRegistry beanDefinitionRegistry;
public ClasspathBeanDefinitionScanner(BeanDefinitionRegistry beanDefinitionRegistry) {
this.beanDefinitionRegistry = beanDefinitionRegistry;
}
@SuppressWarnings("unchecked")
public void doScan(Object... basePackages) {
Reflections reflections = new Reflections(basePackages);
Set<Class<?>> beanClasses = getTypesAnnotatedWith(reflections, Controller.class, Service.class, Repository.class);
for (Class<?> clazz : beanClasses) {
beanDefinitionRegistry.registerBeanDefinition(clazz, new BeanDefinition(clazz));
}
}
@SuppressWarnings("unchecked")
private Set<Class<?>> getTypesAnnotatedWith(Reflections reflections, Class<? extends Annotation>... annotations) {
Set<Class<?>> preInstantiatedBeans = Sets.newHashSet();
for (Class<? extends Annotation> annotation : annotations) {
preInstantiatedBeans.addAll(reflections.getTypesAnnotatedWith(annotation));
}
return preInstantiatedBeans;
}
}
-
์ด๋ก์จ, ๊ฐ ๊ฐ์ฒด์ ์ญํ ์ ๋ถ๋ฆฌํ๋ค.
ClasspathBeanDefinitionScanner๋ ํด๋์คํจ์ค์์ ๋น์ ์กฐํ(getTypesAnnotatedWith())ํ๋ ์ญํ ์ ๋ด๋นํ๊ณ ,- ์กฐํํ ๋น ์ ๋ณด๋ฅผ
BeanDefinition์ ์์ฑํดbeanDefinitionRegistry์ ์ ๋ฌ(beanDefinitionRegistry.registerBeanDefinition(clazz, new BeanDefinition(clazz));) BeanDefinitionRegistry๊ตฌํ์ฒด๊ฐBeanDefinition์ ์ ์ฅ์ ์ญํ ์ ๋ด๋นํ๋ค.
BeanFactory ๋ ๋น ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ณ , ์์กด๊ด๊ณ ์ฃผ์
์ ์ํด์๋ BeanDefinition ์ ๋ณด๊ฐ ํ์ํ๋ค.
- ์ด๋
BeanFactory๊ฐBeanDefinitionRegistry๊ตฌํ์ฒด๋กBeanDefinition์ ๋ณด๋ฅผ ๊ด๋ฆฌํ๋๋ก ๊ตฌํํ๋ค.
public class BeanFactory implements BeanDefinitionRegistry {
private static final Logger logger = LoggerFactory.getLogger(BeanFactory.class);
...
private Map<Class<?>, BeanDefinition> beanDefinitions = Maps.newHashMap();
...
public void initialize() {
for (Class<?> clazz : getBeanClasses()) {
getBean(clazz);
}
}
public Set<Class<?>> getBeanClasses() {
return beanDefinitions.keySet();
}
@Override
public void registerBeanDefinition(Class<?> clazz, BeanDefinition beanDefinition) {
logger.debug("register bean : {]", clazz);
beanDefinitions.put(clazz, beanDefinition);
}
}
BeanFactory ์ ClasspathBeanDefinitionScanner ์ ์์กด๊ด๊ณ์ ๋ํ ์ฐ๊ฒฐ์ ์ด ๋ ํด๋์ค๋ฅผ ํ์ฉํ๋ ๊ณณ์์ ๋ด๋นํ๋ค. ์ง๊ธ๊น์ง๋ AnnotationHandlerMapping ์ด ์ด๋ฅผ ๋ด๋นํ๋ค.
public class AnnotationHandlerMapping implements HandlerMapping {
private static final Logger logger = LoggerFactory.getLogger(AnnotationHandlerMapping.class);
private Object[] basePackage;
private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();
public AnnotationHandlerMapping(Object... basePackage) {
this.basePackage = basePackage;
}
public void initialize() {
BeanFactory beanFactory = new BeanFactory();
ClasspathBeanDefinitionScanner scanner = new ClasspathBeanDefinitionScanner(beanFactory);
scanner.doScan(basePackage);
beanFactory.initialize();
...
}
...
}
BeanFactory ์ ClasspathBeanDefinitionScanner ์ ์์กด๊ด๊ณ ๋ํ DI๋ฅผ ํ์ฉํด ๊ตฌํํ์ฌ ์ ์ฐ์ฑ์ ํ๋ณดํ๋ค.
ClasspathBeanDefinitionScanner๋ ๋จ์ํ ํด๋์ค ํจ์ค์์ ๋น์ ์กฐํํ ํBeanDefinition์ ์์ฑํดBeanDefinitionRegistry์registerBeanDefinition()๋ฉ์๋๋ก ์ ๋ฌํ๋ ์ญํ ์ ๋ด๋นํ๋ค.-
ํ์ง๋ง, ์ด ๊ฒฝ์ฐ ๊ฐ์ฒด ๊ฐ์ DI๋ฅผ ๋ด๋นํ ์ฝ๋๊ฐ ํ์ํ๋ค๋ ๋จ์ ์ด ์๋ค.
- ๊ฐ์ฒด ๊ฐ์ ์์กด๊ด๊ณ๋ฅผ ์ฐ๊ฒฐํ์ง ์์ ์ฑ๋ก API๋ฅผ ์ ๊ณตํ๋ฉด, ์ด๋ฅผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์๋ ์ผ์ผ์ด DI๋ฅผ ํด์ค์ผ ํ๋ค.
- ์ด๋ฌํ ๋จ์ ๋ณด์์ ์ํด ๊ฐ์ฒด ๊ฐ์ DI๋ฅผ ๋ด๋นํ๋ ์๋ก์ด ๊ฐ์ฒด๋ฅผ ์ถ๊ฐํ๋ค. (
ApplicationContext)
public class ApplicationContext {
private BeanFactory beanFactory;
public ApplicationContext(Object... basePackages) {
beanFactory = new BeanFactory();
ClasspathBeanDefinitionScanner scanner = new ClasspathBeanDefinitionScanner(beanFactory);
scanner.doScan(basePackages);
beanFactory.initialize();
}
public <T> T getBean(Class<T> clazz) {
return beanFactory.getBean(clazz);
}
public Set<Class<?>> getBeanClasses() {
return beanFactory.getBeanClasses();
}
}
-
BeanFactory์ด๊ธฐํ ๊ณผ์ ์ApplicationContext๋ก ์ฎ๊ธฐ๊ณ ,BeanFactory๋ก ์ง์ ์ ๊ทผํ๋ API๋ฅผApplicationContext๋ฅผ ํตํด ์ ๊ทผํ๋๋ก ๋ฆฌํฉํ ๋งํ๋ค.- ์ด๋,
BeanFactory๊ฐ ๋ด๋นํ๋getControllers()๋ฉ์๋์ ์ญํ ์ด ์ ํฉํ์ง ์์ ์ด๋ฅผAnnotationHandlerMapping์ผ๋ก ์ด๋ํ๊ณ ๊ตฌํ์ ์ํด ํ์ํ ๊ธฐ๋ฅ๋งApplicationContext๋ฅผ ํตํด ์ ๊ทผํ๋๋ก ๊ตฌํํ๋ค.
- ์ด๋,
public class AnnotationHandlerMapping implements HandlerMapping {
...
public void initialize() {
ApplicationContext ac = new ApplicationContext(basePackage);
Map<Class<?>, Object> controllers = getControllers(ac);
...
}
private Map<Class<?>, Object> getControllers(ApplicationContext ac) {
Map<Class<?>, Object> controllers = Maps.newHashMap();
for (Class<?> clazz : ac.getBeanClasses()) {
Annotation annotation = clazz.getAnnotation(Controller.class);
if (annotation != null) {
controllers.put(clazz, ac.getBean(clazz));
}
}
return controllers;
}
}
- ๊ฐ์ฒด ๊ฐ์ ์์กด๊ด๊ณ ์ฐ๊ฒฐ์ ๋ด๋นํ๋๋ก ๊ตฌํํ์ฌ ๋ ์ด์
BeanFactory๋ฅผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์๊ฐ ์์กด๊ด๊ณ๋๋ฌธ์ ๋จธ๋ฆฌ ์ํํ์ง ์์๋ ๋๋ค. -
๋น ํด๋์ค ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋
BeanDefinition์ ์์ฑ์๋ก ์ ๋ฌ๋๋ ํด๋์ค์์@Inject๊ฐ ์ด๋ป๊ฒ ์ค์ ๋์ด ์๋์ง์ ๋ฐ๋ผInjectType์ ๊ฒฐ์ ํ๋ค. (enum์ฌ์ฉ)- ์ด๋,
InjectType์์๋ ํ๋์setter๋ฉ์๋๋ฅผ ํ์ฉํ@Inject๋ ๋์ผํ๊ฒ ์ทจ๊ธํ๋๋ฐ, ์ด๋ ๋ด๋ถ ๊ตฌํ์ ์ฐจ์ด๊ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค.
- ์ด๋,
- ๋น ํด๋์ค ์ ๋ณด๋ฅผ ํ์ฉํด ๋น ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ณ ์์กด๊ด๊ณ ์ฃผ์
์ ๋ด๋นํ๋
BeanFactory๋ ๋น ํด๋์ค์ ์์กด๊ด๊ณ์ ๊ด๋ จํ ์ ๋ณด ์ฒ๋ฆฌ๋ฅผ ๋ชจ๋BeanDefinition์๊ฒ ์์ํ์ฌ ๋ด๋นํ ์ฑ ์์ด ์ค์๋ค.
๐ฉ ์ค์ ์ถ๊ฐ๋ฅผ ํตํ ์ ์ฐ์ฑ ํ๋ณด
์ง๊ธ๊น์ง ๊ตฌํํ ์ฝ๋๋ฅผ ๋นํ์ ์ธ ์๊ฐ์ผ๋ก ๋ถ์ํ์๋, ์๋์ ๊ฐ์ ๊ฐ์ ์ฌํญ๋ค์ด ๋ณด์ธ๋ค.
DispatcherServlet์init()๋ฉ์๋๋ฅผ ๋ณด๋ฉด"next"๋ผ๋ ํจํค์ง ์ด๋ฆ์ด ํ๋ ์ฝ๋ฉ๋์ด ์๋ค. ๊ธฐ๋ณธ ํจํค์ง๋ช ์ ์ธ๋ถ์์ ์ ๋ฌํ ์ ์๋๋ก ๊ตฌํํ๋ค.-
JdbcTemplate์ด ์์ง๊น์ง ์ฑ๊ธํค ํจํด์ผ๋ก ๊ตฌํ๋์ด ์๋ค. ์ด๋ฅผ DI ํ๋ ์์ํฌ์ ๋น์ผ๋ก ๋ฑ๋กํด ๊ด๋ฆฌํจ์ผ๋ก์จ, ์ฑ๊ธํค ํจํด์ ์ ๊ฑฐํ๋ค.- ์ด๋, ๊ฐ ๋ ์ด์ด์ ๋ช ํํ ์ผ์นํ์ง ์๋ ๋น์ ์ง์ํ๋ annotation์ ์ถ๊ฐํ ํ์๊ฐ ์๋ค.
- DB Connection์ ์์ฑํ๋ ๋ถ๋ถ๋
static์ผ๋ก ๊ตฌํ๋์ด ์๋ค. ๋ํ DB ์ค์ ์ ๋ณด๋ ํ๋ ์ฝ๋ฉ์ผ๋ก ๊ด๋ฆฌ๋์ด ํน์ DB์ ์ข ์๋๋ ๊ตฌ์กฐ์ด๋ค. ์ด๋ฌํ ๊ตฌ์กฐ๋ฅผ ๋ฒ์ด๋๊ณ , Connection Pooling์ ์ง์ํ๊ธฐ ์ํดConnection๋์javax.sql.DataSource์ธํฐํ์ด์ค์ ์์กด๊ด๊ณ๋ฅผ ๊ฐ์ง๋๋ก ๊ฐ์ ํ๋ค.
์ธ๋ฒ์งธ ์ด์๋ DataSource ๊ตฌํ์ฒด๋ก Apache Commons์์ ์ ๊ณตํ๋ DBCP ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํด DB ์ค์ ํ ํ ๋น์ผ๋ก ๋ฑ๋กํ๋ฉด ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
- ์ง๊ธ๊น์ง๋ ๋ชจ๋ ์ง์ ๊ตฌํํ ํด๋์ค๋ฅผ ๋น์ผ๋ก ๋ฑ๋กํ๊ธฐ์ annotation ์ค์ ์ด ๊ฐ๋ฅํ๋ค.
- ํ์ง๋ง DBCP ๊ตฌํ์ฒด์ ๊ฒฝ์ฐ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๊ธฐ๋๋ฌธ์ ์์ ์ด ๋ถ๊ฐ๋ฅํ๋ค. ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ์ ์ํด ๊ตฌํ์ฒด๋ฅผ ์์ํด ๋น ์ค์ ์ ํ๋ฉด ํด๊ฒฐ์ด ๊ฐ๋ฅํ์ง๋ง, ๋งค๋ฒ ์ด๋ฌํ ๊ณผ์ ์ ๊ฑฐ์น๋ ๊ฒ์ ํจ์จ์ ์ด์ง ๋ชปํ๋ค.
- ๋ฐ๋ผ์, ์ฒซ๋ฒ์งธ์ ๋๋ฒ์งธ ์ด์๋ถํฐ ๊ฐ์ ํ๋๋ก ํ๋ค.
๐ง ServletContainerInitializer๋ฅผ ํ์ฉํด web.xml ์์ด ์น ๊ฐ๋ฐํ๊ธฐ
์ฒซ๋ฒ์งธ ์ด์
: ์๋ธ๋ฆฟ์ ์ธ์๋ฅผ ์ ๋ฌํจ์ผ๋ก์จ ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
์๋ธ๋ฆฟ ์ปจํ
์ด๋์ ๊ฒฝ์ฐ, web.xml ์ค์ ์ ํตํด ์๋ธ๋ฆฟ์ ์ธ์๋ฅผ ์ ๋ฌํ ์ ์๋ค. ํ์ง๋ง ์๋ธ๋ฆฟ 3.0 ์ดํ ๋ฒ์ ์์๋ web.xml ์ ์ฌ์ฉํ์ง ์๊ณ ๋ ์ค์ ์ด ๊ฐ๋ฅํ๋ฐ, ์ด๋ ServletContainerInitializer ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํจ์ผ๋ก์จ ๊ฐ๋ฅํ๋ค.
์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ค๋ฉด, ๋จผ์ ํ์ฅ์ ์ํด ์์ฒด์ ์ผ๋ก ์ฌ์ฉํ ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ๋๋ก ํ๋ค. (WebApplicationInitializer)
public interface WebApplicationInitializer {
void onStartup(ServletContext servletContext) throws ServletException;
}
์ ์ธํฐํ์ด์ค์ ๋ํ ๊ตฌํ์ฒด๋ฅผ ๊ตฌํํ๋ค. (MyServletContainerInitializer)
@HandlesTypes(WebApplicationInitializer.class)
public class MyServletContainerInitializer implements ServletContainerInitializer {
@Override
public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
List<WebApplicationInitializer> initializers = new LinkedList<>();
if (webAppInitializerClasses != null) {
for (Class<?> waiClass : webAppInitializerClasses) {
try {
initializers.add((WebApplicationInitializer) waiClass.newInstance());
} catch (Throwable ex) {
throw new ServletException("WebApplicationInitializer class๋ฅผ ์ธ์คํด์คํํ๋๋ฐ ์คํจํ์ต๋๋ค.", ex);
}
}
}
if (initializers.isEmpty()) {
servletContext.log("classpath์์ ๊ฐ์ง๋ Spring WebApplicationInitializer types๊ฐ ์์ต๋๋ค.");
return;
}
for(WebApplicationInitializer initializer : initializers) {
initializer.onStartup(servletContext);
}
}
}
- ์๋ธ๋ฆฟ ์ปจํ
์ด๋๋ ํด๋์คํจ์ค์ ์กด์ฌํ๋ ํด๋์ค ์ค
WebApplicationInitializer์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ๋ชจ๋ ๊ตฌํ์ฒด๋ฅผ ์ฐพ์MyServletContainerInitializer์onStartup()๋ฉ์๋ ์ธ์๋ก ์ ๋ฌํ๋ค. - ํด๋น ๋ฉ์๋๋ ์๋ธ๋ฆฟ ์ปจํ
์ด๋์ ์ ๋ฌํ
WebApplicationInitializer์onStartup()๋ฉ์๋๋ฅผ ์คํํ๋ค.
WebApplicationInitializer์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํจ์ผ๋ก์จ ์๋ธ๋ฆฟ ์ปจํ ์ด๋์ ์ด๊ธฐํ ๊ณผ์ ์ ํ์ฅํ ์ ์๊ฒ ๋์๋ค.
MyServletContainerInitializer ์ onStartup() ๋ฉ์๋ ์คํ์ ์ํด์๋ ์๋ธ๋ฆฟ ์ปจํ
์ด๋๊ฐ ์ด ํด๋์ค๋ฅผ ์ธ์ํ๋ ๊ฒ์ด ๋จผ์ ์ด๋ค. ์ด๋ฅผ ์ํ ์ค์ ์ ํด๋์คํจ์ค์ src/main/resources/META-INF/services ์ javax.servlet.ServletContainerInitializer ํ์ผ์ ์์ฑํด, core.web.MyServletContainerInitializer ์ ์ถ๊ฐํ๋ค.
์ด์ web.xml ์์ด๋ ๊ฐ๋ฐ์ด ๊ฐ๋ฅํ ์ํ๊ฐ ๋์์ผ๋, ํ๋์ฝ๋ฉ์ผ๋ก ๊ตฌํ๋์ด ์๋ ํจํค์ง ์ด๋ฆ์ WebApplicationInitializer ์ ๋ํ ๊ตฌํ์ฒด๋ฅผ ๋ง๋ค์ด ๊ตฌํ ๊ฐ๋ฅํ๋ค.
public class MyWebApplicationInitializer implements WebApplicationInitializer {
private static final Logger log = LoggerFactory.getLogger(MyWebApplicationInitializer.class);
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", new DispatcherServlet("next"));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
log.info("Start MyWebApplication Initializer");
}
}
MyWebApplicationInitializer์์DispatcherServlet์ ์ง์ ์์ฑํด ๋ฑ๋ก(LoadOnStartup,Mapping์์ฑ ๋ํ ๋ฑ๋ก)DispatcherServlet์@WebServletannotation ์ค์ ์ ๋์ด์ ํ์์๋ค.
public class DispatcherServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);
private List<HandlerMapping> mappings = Lists.newArrayList();
private List<HandlerAdapter> handlerAdapters = Lists.newArrayList();
private Object[] basePackages;
public DispatcherServlet(Object... basePackages) {
this.basePackages = basePackages;
}
@Override
public void init() throws ServletException {
AnnotationHandlerMapping ahm = new AnnotationHandlerMapping(basePackages);
ahm.initialize();
mappings.add(ahm);
handlerAdapters.add(new HandlerExecutionHandlerAdapter());
}
...
}
-
init()๋ฉ์๋์์AnnotationHandlerMapping๊ณผ ์ง์ ์ ์ธ ์์กด๊ด๊ณ๋ฅผ ๊ฐ์ง๋ ๊ฒ์ ํ์ธํ ์ ์๋ค. ์ด๋ํ DI๋ฅผ ํตํด ์์กด๊ด๊ณ๋ฅผ ๋์จํ๊ฒ ๊ฐ์ง๋๋ก ๋ณ๊ฒฝํด ํ์ฅ ๊ฐ๋ฅํ๋๋ก ๊ฐ์ ํ ์ ์๋ค.- ์์ฑ์์
HandlerMapping์ ์ธ์๋ก ์ ๋ฌํ ์ ์๋๋ก ๋ฆฌํฉํ ๋งํ๋ค.
- ์์ฑ์์
public class DispatcherServlet extends HttpServlet {
...
private HandlerMapping hm;
public DispatcherServlet(HandlerMapping hm) {
this.hm = hm;
}
@Override
public void init() throws ServletException {
mappings.add(hm);
handlerAdapters.add(new HandlerExecutionHandlerAdapter());
}
...
}
DispatcherServlet์ด ์ด๋HandlerMapping๊ตฌํ์ฒด์ ์์กด๊ด๊ณ๋ฅผ ๊ฐ์ง ๊ฒ์ธ์ง๋DispatcherServlet๋ฅผ ์์ฑํ๋MyApplicationInitializer๊ฐ ๊ฒฐ์ ํ๋ค.
public class MyWebApplicationInitializer implements WebApplicationInitializer {
private static final Logger log = LoggerFactory.getLogger(MyWebApplicationInitializer.class);
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationHandlerMapping ahm = new AnnotationHandlerMapping("next");
ahm.initialize();
ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", new DispatcherServlet(ahm));
...
}
}
๐ง @Component annotation ์ง์
๋๋ฒ์งธ ์ด์
: ClasspathBeanDefinition ํด๋์ค์ @Component annotation ์ค์ ๋ง ์ถ๊ฐํ๋ฉด ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
String value() default "";
}
์ด์ ์ถ๊ฐํ annotation์ ClasspathBeanDefinitionScanner ์ doScan() ๋ฉ์๋๋ก ์ฐพ์ ์ ์๋๋ก ์ถ๊ฐํ๋ค.
public class ClasspathBeanDefinitionScanner {
public void doScan(Object... basePackages) {
Reflections reflections = new Reflections(basePackages);
Set<Class<?>> beanClasses = getTypesAnnotatedWith(reflections, Controller.class, Service.class, Repository.class, Component.class);
for (Class<?> clazz : beanClasses) {
beanDefinitionRegistry.registerBeanDefinition(clazz, new BeanDefinition(clazz));
}
}
}
์ด์ ์ถ๊ฐํ annotation์ ํ์ฉํด JdbcTemplate ์ ๋น์ผ๋ก ๋ฑ๋ก ๊ฐ๋ฅํ๋๋ก ์ค์ ํ ๊ฐ DAO์์ JdbcTemplate ์ DI๋ก ์ฌ์ฉํ๋๋ก ๋ฆฌํฉํ ๋งํ๋ค.
@Component
public class JdbcTemplate {
...
}
@Repository
public class JdbcQuestionDao implements QuestionDao {
private JdbcTemplate jdbcTemplate;
@Inject
public JdbcQuestionDao(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
...
}
@Repository
public class JdbcAnswerDao implements AnswerDao {
private JdbcTemplate jdbcTemplate;
@Inject
public JdbcAnswerDao(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
...
}
์๋ฒ๋ฅผ ์์ํ๋ฉด JdbcTemplate ์ด "next" ํจํค์ง๊ฐ ์๋ "core" ํจํค์ง ์๋์ ์์ด ์ธ์ํ์ง ๋ชปํด ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
MyWebApplicationInitializer์์ ์ด๋ฅผ ์ธ์ํ๋๋กAnnotationHandlerMapping์"core"๋ฅผ ์ถ๊ฐํด ์ ๋ฌํ๋ค.
public class MyWebApplicationInitializer implements WebApplicationInitializer {
private static final Logger log = LoggerFactory.getLogger(MyWebApplicationInitializer.class);
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationHandlerMapping ahm = new AnnotationHandlerMapping("core", "next");
...
}
}
๐ฉ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํด๋์ค๋ฅผ ๋น์ผ๋ก ๋ฑ๋กํ๊ธฐ
๐ง ์๊ตฌ์ฌํญ
๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ ๊ฐ๋ฐ์๊ฐ ์ง์ ๋น์ ์์ฑํด ๊ด๋ฆฌํ ์ ์๋ ๋ณ๋์ ์ค์ ํ์ผ์ ๋ง๋๋ ๊ฒ์ด๋ค.
- ์๋ฅผ ๋ค์ด, ์ค์ ํ์ผ์ ๋น ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ ๋ฉ์๋๋ฅผ ๊ตฌํํด๋๊ณ , annotation์ผ๋ก ์ค์ ํ๋ค.
- DI ํ๋ ์์ํฌ๋ ์ด ์ค์ ํ์ผ์ ์ฝ์ด
BeanFactory์ ๋น์ผ๋ก ์ ์ฅํ ์ ์๋ค๋ฉดClasspathBeanDefinitionScanner๋ฅผ ํตํด ๋ฑ๋กํ ๋น๊ณผ ๊ฐ์ ์ ์ฅ์์์ ๊ด๋ฆฌํ ์ ์๋ค.
annotation์ ์ด์ฉํด ๋ชจ๋ ์ค์ ์ ๊ด๋ฆฌํ๊ณ ๊ธฐ๋ณธ ํจํค์ง ์ค์ ๋ํ ์์ฑํ๋ ์ค์ ํ์ผ์์ ๊ด๋ฆฌํ๋๋ก ๋ฆฌํฉํ ๋งํ๋ค.
@Configuration
@ComponentScan({"next", "core"})
public class MyConfiguration {
@Bean
public DataSource dataSource() {
BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName("org.h2.Driver");
ds.setUrl("jdbc:h2:~/jwp-basic;AUTO_SERVER=TRUE");
ds.setUsername("sa");
ds.setPassword("");
return ds;
}
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
- ์๋ฐ ํด๋์ค๊ฐ "์ค์ ํ์ผ"์ด๋ผ๋ ํ์๋
@Configurationannotation์ ์์ฑํด ์ฌ์ฉํ๋ค. - ๊ฐ ๋ฉ์๋์์ ์์ฑํ๋ ์ธ์คํด์ค๊ฐ
BeanFactory์ ๋น์ผ๋ก ๋ฑ๋กํ๋ผ๋ ์ค์ ์Beanannotation์ ์์ฑํด ์ฌ์ฉํ๋ค. ClasspathBeanDefinitionScanner์์ ์ฌ์ฉํ ๊ธฐ๋ณธ ํจํค์ง์ ๋ํ ์ค์ ์ ํ๋ ์ฝ๋ฉํ๋๋ฐ ์ด๋ฅผ ์ค์ ํ์ผ์์@ComponentScanannotation์ ์ฌ์ฉํด ์ค์ ํ๋๋ก ์ง์ํ๋ค.@Configuration์ค์ ํ์ผ์ ํตํด ๋ฑ๋กํ ๋น๊ณผClasspathBeanDefinitionScanner๋ฅผ ํตํด ๋ฑ๋กํ ๋น ๊ฐ์ DI๊ฐ ๊ฐ๋ฅํด์ผ ํ๋ค.
๐ง 1๋จ๊ณ ํํธ
๋ฐ๋ก ๊ตฌํ์ ์์ํ๊ธฐ๋ณด๋ค ์๊ตฌ์ฌํญ์ ํ ์คํธํ ์ ์๋ ๋จ์ ํ ์คํธ๋ฅผ ๋จผ์ ๊ตฌํํ๋ค.
-
๋จผ์ ์ค์ ํ์ผ์์ ์ฌ์ฉํ annotation์ ์ถ๊ฐํ๋ค.
ComponentScan์ ๋ฐฐ์ด์ ๊ฐ์ผ๋ก ์ ๋ฌํ ์ ์๋๋กString[]ํ๋๋ฅผ ๊ฐ์ง๋ค.
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
String[] value() default {};
String[] basePackages() default {};
}
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Configuration {
}
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
}
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ฉด @Configuration ์ค์ ํ์ผ์ ์ฝ์ด BeanFactory ์ BeanDefinition ์ ๋ฑ๋กํ๋ ์ญํ ์ ์ํํ ํด๋์ค๊ฐ ํ์ํ๋ค. (AnnotatedBeanDefinitionReader)
@Configuration์ค์ ๋ ํด๋์ค์์@Bean์ค์ ๋ ๋ฉ์๋๋ฅผ ์ฐพ๋๋ค.BeanFactory์ ๋ฑ๋กํ ๋น์@Bean๋ฉ์๋์ ๋ฐํ ๊ฐ์ ํด๋นํ๋ ํด๋์ค์ด๋ค.- ๋ฉ์๋์ ๋ฐํ ํด๋์ค์ ํด๋นํ๋
BeanDefinition์ ์์ฑํ ํBeanFactory์ ๋ฑ๋กํ๋ค.
์ด๋ ๊ณ ๋ คํด์ผ ํ๋ ์ ์ ๋น ์ธ์คํด์ค ์์ฑ์ ์ํด
@Bean์ค์ ๋ ๋ฉ์๋(๋ฆฌํ๋ ์ ์Method)์ ์ ๋ณด๊ฐ ํ์ํ๋ค๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์, ๊ธฐ์กด์BeanDefinition์ ์์ํ๋AnnotatedBeanDefinition์ ์ถ๊ฐํ ํ ๋ฉ์๋ ์ ๋ณด๊น์ง ์ ๋ฌํ๋ค.
์ดํ ๊ฐ์ฅ ์ค์ํ BeanFactory ์ getBean() ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ค.
- ์ธ์๋ก ์ ๋ฌ๋๋ ๋น ํด๋์ค์ ํด๋นํ๋
BeanDefinition์ดAnnotatedBeanDefinition์ธ์คํด์ค์ผ ๊ฒฝ์ฐ ๊ธฐ์กด๊ณผ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ๋น ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ค.
๋ง์ง๋ง์ผ๋ก, ApplicationContext ๊ฐ ClasspathBeanDefinitionScanner ์์ ์ฌ์ฉํ ๊ธฐ๋ณธ ํจํค์ง ์ ๋ณด๋ฅผ ๋ฐ๋ ๊ฒ์ด ์๋ @Configuration ์ค์ ๋ ์ค์ ํ์ผ์ ์ธ์๋ก ๋ฐ๋๋ก ์์ ํ ํ @ComponentScan ๊ฐ์ ๊ตฌํด ํจํค์ง ์ ๋ณด๋ฅผ ์ ๋ฌํ๊ณ , AnnotatedBeanDefinitionReader ๋ฅผ ํตํด ์ค์ ํ์ผ์ ๋ฑ๋ก๋ @Bean ์ BeanFactory ์ ๋ฑ๋กํ๋๋ก ํ๋ค.
๐ง 2๋จ๊ณ ํํธ
๋จ์ ํ
์คํธ ์ฝ๋ ๋ง๋ค๊ธฐ
๋จผ์ ํ
์คํธ์ฉ ์ค์ ํ์ผ์ ์ถ๊ฐํ๋ค. (src/test/java)
@Configuration
public class ExampleConfig {
@Bean
public DataSource dataSource() {
BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName("org.h2.Driver");
ds.setUrl("jdbc:h2:~/jwp-basic;AUTO_SERVER=TRUE");
ds.setUsername("sa");
ds.setPassword("");
return ds;
}
}
- ํด๋น ์ค์ ํ์ผ์ ์ฝ์ด
BeanFactory์ ๋ฑ๋กํ ํgetBean()์ ํตํด ๋น์ ์ฐพ์์ ๋null์ฌ๋ถ๋ฅผ ํ๋จํ๋ ํ ์คํธ๋ฅผ ์ถ๊ฐํ๋ค.
๐ ์ถ์ฒ
- ์๋ฐ ์น ํ๋ก๊ทธ๋๋ฐ Next Step : ํ๋์ฉ ๋ฒ๊ฒจ๊ฐ๋ ์ํ๊ป์ง ํ์ต๋ฒ - ๋ฐ์ฌ์ฑ
- java - Maven์ ์ฌ์ฉํ๋ JAR์ "META-INF/services"ํด๋์ ์ค์ ํ์ผ์ ํฌํจ์ํค๋ ๋ฐฉ๋ฒ